/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Logic;

import java.io.IOException;
import java.util.Vector;

/**
 *
 * @author Usuario
 */
public class MatricesOperaciones {

    public void MatricesOperaciones() {
    }
    /*
     * Devuelve "true" si el "size" de la matriz es igual al "size" de la matriz m2.
     */

    public boolean igualsize(Vector<Vector> a1, Vector<Vector> a2) {

        if (a1.size() == a2.size()) {
            if (a1.elementAt(0).size() == a2.elementAt(0).size()) {
                return true;
            } else {
                return false;
            }
        }
        return false;

    }

    /*
     * Esta funcion trata las columnas de la matriz como vectores, de la cual
     * crea un vector fila que contiene el elemento mínimo de cada columna, y
     * luego devuelve el elemento mas pequeño de ese vector.
     */
    public Double minMin(Vector<Vector> m) {

        int columnas = m.size();
        int filas = m.elementAt(0).size();
        Vector<Double> minimos = new Vector<Double>(columnas);
        double min;
        double aux = (double) m.elementAt(0).elementAt(0);

        for (int i = 0; i < columnas; i++) {
            for (int j = 0; j < filas; j++) {
                if ((double) m.elementAt(i).elementAt(j) < aux) {
                    aux = (double) m.elementAt(i).elementAt(j);
                }

            }
            minimos.add(aux);
        }

        min = (double) minimos.elementAt(0);
        for (int k = 0; k < columnas; k++) {
            if (minimos.elementAt(k) < min) {
                min = minimos.elementAt(k);
            }
        }

        return min;
    }

    /*
     * Esta funcion trata las columnas de la matriz como vectores, de la cual
     * crea un vector fila que contiene el elemento máximo de cada columna, y
     * luego devuelve el elemento mas grande de ese vector.
     */
    public Double maxMax(Vector<Vector> m) {

        int columnas = m.size();
        int filas = m.elementAt(0).size();
        Vector<Double> minimos = new Vector<Double>(columnas);
        double max;
        double aux = (double) m.elementAt(0).elementAt(0);

        for (int i = 0; i < columnas; i++) {
            for (int j = 0; j < filas; j++) {
                if ((double) m.elementAt(i).elementAt(j) > aux) {
                    aux = (double) m.elementAt(i).elementAt(j);
                }

            }
            minimos.add(aux);
        }

        max = (double) minimos.elementAt(0);
        for (int k = 0; k < columnas; k++) {
            if (minimos.elementAt(k) > max) {
                max = minimos.elementAt(k);
            }
        }

        return max;
    }

    public Vector<Vector> funcionFor(Vector<Vector> A1, Vector<Vector> A2, String ruta, Double dTA, Double dosed) throws IOException {


        Vector<Integer> auxA1 = new Vector<Integer>();
        Vector<Integer> auxA2 = new Vector<Integer>();

        auxA1.add(0, A1.size());
        auxA1.add(1, A1.elementAt(0).size());

        auxA2.add(0, A2.size());
        auxA2.add(1, A2.elementAt(0).size());

        Vector<Vector> Ga = new Vector<Vector>();
        Vector<Vector> G = new Vector<Vector>();
        Vector<Double> temp = new Vector<Double>();

        for (int i = 0; i < A1.size(); i++) {
            for (int j = 0; j < A1.elementAt(0).size(); j++) {
                temp.add(new Double(0));
            }
            Ga.add(temp);
            temp = new Vector<Double>();
        }
        for (int i = 0; i < A1.size(); i++) {
            for (int j = 0; j < A1.elementAt(0).size(); j++) {
                temp.add(new Double(0));
            }
            G.add(temp);
            temp = new Vector<Double>();
        }

        double r2; // Distancia (radio) al cuadrado
        double d2; // Diferencia al cuadrado

        if (this.igualsize(A1, A2)) {
            for (Integer i = 0; i < auxA1.elementAt(0); i++) {//System.out.println(aux1.toString()+"\n");
                for (Integer j = 0; j < auxA1.elementAt(1); j++) {//System.out.println(aux2.toString()+"\n");
                    for (Integer k = 0; k < auxA1.elementAt(0); k++) {//System.out.println(aux3.toString()+"\n");
                        for (Integer l = 0; l < auxA1.elementAt(1); l++) {//System.out.println(aux4.toString()+"\n");
                            r2 = Math.pow((i.doubleValue() - k.doubleValue()), 2) + Math.pow((j.doubleValue() - l.doubleValue()), 2);
                            d2 = Math.pow(((double) A1.elementAt(i).elementAt(j) - (double) A2.elementAt(k).elementAt(l)), 2);
                            Double auxGa = Math.sqrt((r2 / Math.pow(dTA, 2)) + (d2 / Math.pow(dosed, 2)));
                            Ga.elementAt(k.intValue()).setElementAt(auxGa, l.intValue());//lxk

                        }
                    }
                    G.elementAt(i.intValue()).setElementAt(this.minMin(Ga)/**
                             * 2
                             */
                            , j.intValue());//tiene el "*2" para que de igual que matlab
                }
            }
        } else {
            System.out.println("Las matrices A1 y A2 no tienen las mismas dimensiones");
        }

        try {
            EscritorMatrices w = new EscritorMatrices(ruta, "matrizGa");
            w.GuardarArchivo(Ga);

        } catch (IOException e) {
            throw e;
        }
        return G;
    }
}
